/*
************************************************************************************************************************
*                                                      uC/OS-III
*                                                 The Real-Time Kernel
*
*                                  (c) Copyright 2009-2012; Micrium, Inc.; Weston, FL
*                           All rights reserved.  Protected by international copyright laws.
*
*                                                 SEMAPHORE MANAGEMENT
*
* File    : OS_SEM.C
* By      : JJL
* Version : V3.03.01
*
* LICENSING TERMS:
* ---------------
*           uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or
*           for peaceful research.  If you plan or intend to use uC/OS-III in a commercial application/
*           product then, you need to contact Micrium to properly license uC/OS-III for its use in your
*           application/product.   We provide ALL the source code for your convenience and to help you
*           experience uC/OS-III.  The fact that the source is provided does NOT mean that you can use
*           it commercially without paying a licensing fee.
*
*           Knowledge of the source code may NOT be used to develop a similar product.
*
*           Please help us continue to provide the embedded community with the finest software available.
*           Your honesty is greatly appreciated.
*
*           You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036.
************************************************************************************************************************
*/

#define  MICRIUM_SOURCE
#include <os.h>

#ifdef VSC_INCLUDE_SOURCE_FILE_NAMES
const  CPU_CHAR  *os_sem__c = "$Id: $";
#endif


#if OS_CFG_SEM_EN > 0u
/*
************************************************************************************************************************
*                                                  CREATE A SEMAPHORE
*
* Description: This function creates a semaphore.
*
* Arguments  : p_sem         is a pointer to the semaphore to initialize.  Your application is responsible for
*                            allocating storage for the semaphore.
*
*              p_name        is a pointer to the name you would like to give the semaphore.
*
*              cnt           is the initial value for the semaphore.
*                            If used to share resources, you should initialize to the number of resources available.
*                            If used to signal the occurrence of event(s) then you should initialize to 0.
*
*              p_err         is a pointer to a variable that will contain an error code returned by this function.
*
*                                OS_ERR_NONE                    if the call was successful
*                                OS_ERR_CREATE_ISR              if you called this function from an ISR
*                                OS_ERR_ILLEGAL_CREATE_RUN_TIME if you are trying to create the semaphore after you
*                                                                 called OSSafetyCriticalStart().
*                                OS_ERR_NAME                    if 'p_name' is a NULL pointer
*                                OS_ERR_OBJ_CREATED             if the semaphore has already been created
*                                OS_ERR_OBJ_PTR_NULL            if 'p_sem'  is a NULL pointer
*                                OS_ERR_OBJ_TYPE                if 'p_sem' has already been initialized to a different
*                                                               object type
*
* Returns    : none
************************************************************************************************************************
*/

void  OSSemCreate ( OS_SEM      *p_sem,
                    CPU_CHAR    *p_name,
                    OS_SEM_CTR   cnt,
                    OS_ERR      *p_err )
{
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#ifdef OS_SAFETY_CRITICAL_IEC61508
    if ( OSSafetyCriticalStartFlag == DEF_TRUE )
    {
        *p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if ( OSIntNestingCtr > ( OS_NESTING_CTR ) 0 )           /* Not allowed to be called from an ISR                   */
    {
        *p_err = OS_ERR_CREATE_ISR;
        return;
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if ( p_sem == ( OS_SEM * ) 0 )                          /* Validate 'p_sem'                                       */
    {
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return;
    }
#endif

    OS_CRITICAL_ENTER();
    p_sem->Type    = OS_OBJ_TYPE_SEM;                       /* Mark the data structure as a semaphore                 */
    p_sem->Ctr     = cnt;                                   /* Set semaphore value                                    */
    p_sem->TS      = ( CPU_TS ) 0;
    p_sem->NamePtr = p_name;                                /* Save the name of the semaphore                         */
    OS_PendListInit ( &p_sem->PendList );                   /* Initialize the waiting list                            */

#if OS_CFG_DBG_EN > 0u
    OS_SemDbgListAdd ( p_sem );
#endif
    OSSemQty++;

    OS_CRITICAL_EXIT_NO_SCHED();
    *p_err = OS_ERR_NONE;
}

/*$PAGE*/
/*
************************************************************************************************************************
*                                                  DELETE A SEMAPHORE
*
* Description: This function deletes a semaphore.
*
* Arguments  : p_sem         is a pointer to the semaphore to delete
*
*              opt           determines delete options as follows:
*
*                                OS_OPT_DEL_NO_PEND          Delete semaphore ONLY if no task pending
*                                OS_OPT_DEL_ALWAYS           Deletes the semaphore even if tasks are waiting.
*                                                            In this case, all the tasks pending will be readied.
*
*              p_err         is a pointer to a variable that will contain an error code returned by this function.
*
*                                OS_ERR_NONE                 The call was successful and the semaphore was deleted
*                                OS_ERR_DEL_ISR              If you attempted to delete the semaphore from an ISR
*                                OS_ERR_OBJ_PTR_NULL         If 'p_sem' is a NULL pointer.
*                                OS_ERR_OBJ_TYPE             If 'p_sem' is not pointing at a semaphore
*                                OS_ERR_OPT_INVALID          An invalid option was specified
*                                OS_ERR_TASK_WAITING         One or more tasks were waiting on the semaphore
*
* Returns    : == 0          if no tasks were waiting on the semaphore, or upon error.
*              >  0          if one or more tasks waiting on the semaphore are now readied and informed.
*
* Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of the semaphore
*                 MUST check the return code of OSSemPend().
*              2) OSSemAccept() callers will not know that the intended semaphore has been deleted.
*              3) Because ALL tasks pending on the semaphore will be readied, you MUST be careful in applications where
*                 the semaphore is used for mutual exclusion because the resource(s) will no longer be guarded by the
*                 semaphore.
************************************************************************************************************************
*/

#if OS_CFG_SEM_DEL_EN > 0u
OS_OBJ_QTY  OSSemDel ( OS_SEM  *p_sem,
                       OS_OPT   opt,
                       OS_ERR  *p_err )
{
    OS_OBJ_QTY     cnt;
    OS_OBJ_QTY     nbr_tasks;
    OS_PEND_DATA  *p_pend_data;
    OS_PEND_LIST  *p_pend_list;
    OS_TCB        *p_tcb;
    CPU_TS         ts;
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return ( ( OS_OBJ_QTY ) 0 );
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if ( OSIntNestingCtr > ( OS_NESTING_CTR ) 0 )           /* Not allowed to delete a semaphore from an ISR          */
    {
        *p_err = OS_ERR_DEL_ISR;
        return ( ( OS_OBJ_QTY ) 0 );
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if ( p_sem == ( OS_SEM * ) 0 )                          /* Validate 'p_sem'                                       */
    {
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return ( ( OS_OBJ_QTY ) 0 );
    }
    switch ( opt )                                          /* Validate 'opt'                                         */
    {
    case OS_OPT_DEL_NO_PEND:
    case OS_OPT_DEL_ALWAYS:
        break;

    default:
        *p_err = OS_ERR_OPT_INVALID;
        return ( ( OS_OBJ_QTY ) 0 );
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
    if ( p_sem->Type != OS_OBJ_TYPE_SEM )                   /* Make sure semaphore was created                        */
    {
        *p_err = OS_ERR_OBJ_TYPE;
        return ( ( OS_OBJ_QTY ) 0 );
    }
#endif

    CPU_CRITICAL_ENTER();
    p_pend_list = &p_sem->PendList;
    cnt         = p_pend_list->NbrEntries;
    nbr_tasks   = cnt;
    switch ( opt )
    {
    case OS_OPT_DEL_NO_PEND:                            /* Delete semaphore only if no task waiting               */
        if ( nbr_tasks == ( OS_OBJ_QTY ) 0 )
        {
#if OS_CFG_DBG_EN > 0u
            OS_SemDbgListRemove ( p_sem );
#endif
            OSSemQty--;
            OS_SemClr ( p_sem );
            CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_NONE;
        }
        else
        {
            CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_WAITING;
        }
        break;

    case OS_OPT_DEL_ALWAYS:                             /* Always delete the semaphore                            */
        OS_CRITICAL_ENTER_CPU_EXIT();
        ts = OS_TS_GET();                              /* Get local time stamp so all tasks get the same time    */
        while ( cnt > 0u )                             /* Remove all tasks on the pend list                      */
        {
            p_pend_data = p_pend_list->HeadPtr;
            p_tcb       = p_pend_data->TCBPtr;
            OS_PendObjDel ( ( OS_PEND_OBJ * ) ( ( void * ) p_sem ),
                            p_tcb,
                            ts );
            cnt--;
        }
#if OS_CFG_DBG_EN > 0u
        OS_SemDbgListRemove ( p_sem );
#endif
        OSSemQty--;
        OS_SemClr ( p_sem );
        OS_CRITICAL_EXIT_NO_SCHED();
        OSSched();                                     /* Find highest priority task ready to run                */
        *p_err = OS_ERR_NONE;
        break;

    default:
        CPU_CRITICAL_EXIT();
        *p_err = OS_ERR_OPT_INVALID;
        break;
    }
    return ( ( OS_OBJ_QTY ) nbr_tasks );
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                                  PEND ON SEMAPHORE
*
* Description: This function waits for a semaphore.
*
* Arguments  : p_sem         is a pointer to the semaphore
*
*              timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will wait for the
*                            resource up to the amount of time (in 'ticks') specified by this argument.  If you specify
*                            0, however, your task will wait forever at the specified semaphore or, until the resource
*                            becomes available (or the event occurs).
*
*              opt           determines whether the user wants to block if the semaphore is not available or not:
*
*                                OS_OPT_PEND_BLOCKING
*                                OS_OPT_PEND_NON_BLOCKING
*
*              p_ts          is a pointer to a variable that will receive the timestamp of when the semaphore was posted
*                            or pend aborted or the semaphore deleted.  If you pass a NULL pointer (i.e. (CPU_TS*)0)
*                            then you will not get the timestamp.  In other words, passing a NULL pointer is valid
*                            and indicates that you don't need the timestamp.
*
*              p_err         is a pointer to a variable that will contain an error code returned by this function.
*
*                                OS_ERR_NONE               The call was successful and your task owns the resource
*                                                          or, the event you are waiting for occurred.
*                                OS_ERR_OBJ_DEL            If 'p_sem' was deleted
*                                OS_ERR_OBJ_PTR_NULL       If 'p_sem' is a NULL pointer.
*                                OS_ERR_OBJ_TYPE           If 'p_sem' is not pointing at a semaphore
*                                OS_ERR_OPT_INVALID        If you specified an invalid value for 'opt'
*                                OS_ERR_PEND_ABORT         If the pend was aborted by another task
*                                OS_ERR_PEND_ISR           If you called this function from an ISR and the result
*                                                          would lead to a suspension.
*                                OS_ERR_PEND_WOULD_BLOCK   If you specified non-blocking but the semaphore was not
*                                                          available.
*                                OS_ERR_SCHED_LOCKED       If you called this function when the scheduler is locked
*                                OS_ERR_STATUS_INVALID     Pend status is invalid
*                                OS_ERR_TIMEOUT            The semaphore was not received within the specified
*                                                          timeout.
*
*
* Returns    : The current value of the semaphore counter or 0 if not available.
************************************************************************************************************************
*/

OS_SEM_CTR  OSSemPend ( OS_SEM   *p_sem,
                        OS_TICK   timeout,
                        OS_OPT    opt,
                        CPU_TS   *p_ts,
                        OS_ERR   *p_err )
{
    OS_SEM_CTR    ctr;
    OS_PEND_DATA  pend_data;
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if ( OSIntNestingCtr > ( OS_NESTING_CTR ) 0 )           /* Not allowed to call from an ISR                        */
    {
        *p_err = OS_ERR_PEND_ISR;
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if ( p_sem == ( OS_SEM * ) 0 )                          /* Validate 'p_sem'                                       */
    {
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return ( ( OS_SEM_CTR ) 0 );
    }
    switch ( opt )                                          /* Validate 'opt'                                         */
    {
    case OS_OPT_PEND_BLOCKING:
    case OS_OPT_PEND_NON_BLOCKING:
        break;

    default:
        *p_err = OS_ERR_OPT_INVALID;
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
    if ( p_sem->Type != OS_OBJ_TYPE_SEM )                   /* Make sure semaphore was created                        */
    {
        *p_err = OS_ERR_OBJ_TYPE;
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

    if ( p_ts != ( CPU_TS * ) 0 )
    {
        *p_ts  = ( CPU_TS ) 0;                               /* Initialize the returned timestamp                      */
    }
    CPU_CRITICAL_ENTER();
    if ( p_sem->Ctr > ( OS_SEM_CTR ) 0 )                    /* Resource available?                                    */
    {
        p_sem->Ctr--;                                       /* Yes, caller may proceed                                */
        if ( p_ts != ( CPU_TS * ) 0 )
        {
            *p_ts  = p_sem->TS;                              /*      get timestamp of last post                        */
        }
        ctr   = p_sem->Ctr;
        CPU_CRITICAL_EXIT();
        *p_err = OS_ERR_NONE;
        return ( ctr );
    }

    if ( ( opt & OS_OPT_PEND_NON_BLOCKING ) != ( OS_OPT ) 0 ) /* Caller wants to block if not available?                */
    {
        ctr   = p_sem->Ctr;                                 /* No                                                     */
        CPU_CRITICAL_EXIT();
        *p_err = OS_ERR_PEND_WOULD_BLOCK;
        return ( ctr );
    }
    else                                                    /* Yes                                                    */
    {
        if ( OSSchedLockNestingCtr > ( OS_NESTING_CTR ) 0 ) /* Can't pend when the scheduler is locked                */
        {
            CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_SCHED_LOCKED;
            return ( ( OS_SEM_CTR ) 0 );
        }
    }
    /* Lock the scheduler/re-enable interrupts                */
    OS_CRITICAL_ENTER_CPU_EXIT();
    OS_Pend ( &pend_data,                                   /* Block task pending on Semaphore                        */
              ( OS_PEND_OBJ * ) ( ( void * ) p_sem ),
              OS_TASK_PEND_ON_SEM,
              timeout );

    OS_CRITICAL_EXIT_NO_SCHED();

    OSSched();                                              /* Find the next highest priority task ready to run       */

    CPU_CRITICAL_ENTER();
    switch ( OSTCBCurPtr->PendStatus )
    {
    case OS_STATUS_PEND_OK:                             /* We got the semaphore                                   */
        if ( p_ts != ( CPU_TS * ) 0 )
        {
            *p_ts  =  OSTCBCurPtr->TS;
        }
        *p_err = OS_ERR_NONE;
        break;

    case OS_STATUS_PEND_ABORT:                          /* Indicate that we aborted                               */
        if ( p_ts != ( CPU_TS * ) 0 )
        {
            *p_ts  =  OSTCBCurPtr->TS;
        }
        *p_err = OS_ERR_PEND_ABORT;
        break;

    case OS_STATUS_PEND_TIMEOUT:                        /* Indicate that we didn't get semaphore within timeout   */
        if ( p_ts != ( CPU_TS * ) 0 )
        {
            *p_ts  = ( CPU_TS  ) 0;
        }
        *p_err = OS_ERR_TIMEOUT;
        break;

    case OS_STATUS_PEND_DEL:                            /* Indicate that object pended on has been deleted        */
        if ( p_ts != ( CPU_TS * ) 0 )
        {
            *p_ts  =  OSTCBCurPtr->TS;
        }
        *p_err = OS_ERR_OBJ_DEL;
        break;

    default:
        *p_err = OS_ERR_STATUS_INVALID;
        CPU_CRITICAL_EXIT();
        return ( ( OS_SEM_CTR ) 0 );
    }
    ctr = p_sem->Ctr;
    CPU_CRITICAL_EXIT();
    return ( ctr );
}

/*$PAGE*/
/*
************************************************************************************************************************
*                                             ABORT WAITING ON A SEMAPHORE
*
* Description: This function aborts & readies any tasks currently waiting on a semaphore.  This function should be used
*              to fault-abort the wait on the semaphore, rather than to normally signal the semaphore via OSSemPost().
*
* Arguments  : p_sem     is a pointer to the semaphore
*
*              opt       determines the type of ABORT performed:
*
*                            OS_OPT_PEND_ABORT_1          ABORT wait for a single task (HPT) waiting on the semaphore
*                            OS_OPT_PEND_ABORT_ALL        ABORT wait for ALL tasks that are  waiting on the semaphore
*                            OS_OPT_POST_NO_SCHED         Do not call the scheduler
*
*              p_err     is a pointer to a variable that will contain an error code returned by this function.
*
*                            OS_ERR_NONE                  At least one task waiting on the semaphore was readied and
*                                                         informed of the aborted wait; check return value for the
*                                                         number of tasks whose wait on the semaphore was aborted.
*                            OS_ERR_OBJ_PTR_NULL          If 'p_sem' is a NULL pointer.
*                            OS_ERR_OBJ_TYPE              If 'p_sem' is not pointing at a semaphore
*                            OS_ERR_OPT_INVALID           If you specified an invalid option
*                            OS_ERR_PEND_ABORT_ISR        If you called this function from an ISR
*                            OS_ERR_PEND_ABORT_NONE       No task were pending
*
* Returns    : == 0          if no tasks were waiting on the semaphore, or upon error.
*              >  0          if one or more tasks waiting on the semaphore are now readied and informed.
************************************************************************************************************************
*/

#if OS_CFG_SEM_PEND_ABORT_EN > 0u
OS_OBJ_QTY  OSSemPendAbort ( OS_SEM  *p_sem,
                             OS_OPT   opt,
                             OS_ERR  *p_err )
{
    OS_PEND_LIST  *p_pend_list;
    OS_TCB        *p_tcb;
    CPU_TS         ts;
    OS_OBJ_QTY     nbr_tasks;
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return ( ( OS_OBJ_QTY ) 0u );
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if ( OSIntNestingCtr > ( OS_NESTING_CTR ) 0u )          /* Not allowed to Pend Abort from an ISR                  */
    {
        *p_err =  OS_ERR_PEND_ABORT_ISR;
        return ( ( OS_OBJ_QTY ) 0u );
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if ( p_sem == ( OS_SEM * ) 0 )                          /* Validate 'p_sem'                                       */
    {
        *p_err =  OS_ERR_OBJ_PTR_NULL;
        return ( ( OS_OBJ_QTY ) 0u );
    }
    switch ( opt )                                          /* Validate 'opt'                                         */
    {
    case OS_OPT_PEND_ABORT_1:
    case OS_OPT_PEND_ABORT_ALL:
    case OS_OPT_PEND_ABORT_1   | OS_OPT_POST_NO_SCHED:
    case OS_OPT_PEND_ABORT_ALL | OS_OPT_POST_NO_SCHED:
        break;

    default:
        *p_err =  OS_ERR_OPT_INVALID;
        return ( ( OS_OBJ_QTY ) 0u );
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
    if ( p_sem->Type != OS_OBJ_TYPE_SEM )                   /* Make sure semaphore was created                        */
    {
        *p_err =  OS_ERR_OBJ_TYPE;
        return ( ( OS_OBJ_QTY ) 0u );
    }
#endif

    CPU_CRITICAL_ENTER();
    p_pend_list = &p_sem->PendList;
    if ( p_pend_list->NbrEntries == ( OS_OBJ_QTY ) 0u )     /* Any task waiting on semaphore?                         */
    {
        CPU_CRITICAL_EXIT();                                /* No                                                     */
        *p_err =  OS_ERR_PEND_ABORT_NONE;
        return ( ( OS_OBJ_QTY ) 0u );
    }

    OS_CRITICAL_ENTER_CPU_EXIT();
    nbr_tasks = 0u;
    ts        = OS_TS_GET();                                /* Get local time stamp so all tasks get the same time    */
    while ( p_pend_list->NbrEntries > ( OS_OBJ_QTY ) 0u )
    {
        p_tcb = p_pend_list->HeadPtr->TCBPtr;
        OS_PendAbort ( ( OS_PEND_OBJ * ) ( ( void * ) p_sem ),
                       p_tcb,
                       ts );
        nbr_tasks++;
        if ( opt != OS_OPT_PEND_ABORT_ALL )                 /* Pend abort all tasks waiting?                          */
        {
            break;                                          /* No                                                     */
        }
    }
    OS_CRITICAL_EXIT_NO_SCHED();

    if ( ( opt & OS_OPT_POST_NO_SCHED ) == ( OS_OPT ) 0u )
    {
        OSSched();                                          /* Run the scheduler                                      */
    }

    *p_err = OS_ERR_NONE;
    return ( nbr_tasks );
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                                 POST TO A SEMAPHORE
*
* Description: This function signals a semaphore
*
* Arguments  : p_sem    is a pointer to the semaphore
*
*              opt      determines the type of POST performed:
*
*                           OS_OPT_POST_1            POST and ready only the highest priority task waiting on semaphore
*                                                    (if tasks are waiting).
*                           OS_OPT_POST_ALL          POST to ALL tasks that are waiting on the semaphore
*
*                           OS_OPT_POST_NO_SCHED     Do not call the scheduler
*
*                           Note(s): 1) OS_OPT_POST_NO_SCHED can be added with one of the other options.
*
*              p_err    is a pointer to a variable that will contain an error code returned by this function.
*
*                           OS_ERR_NONE          The call was successful and the semaphore was signaled.
*                           OS_ERR_OBJ_PTR_NULL  If 'p_sem' is a NULL pointer.
*                           OS_ERR_OBJ_TYPE      If 'p_sem' is not pointing at a semaphore
*                           OS_ERR_SEM_OVF       If the post would cause the semaphore count to overflow.
*
* Returns    : The current value of the semaphore counter or 0 upon error.
************************************************************************************************************************
*/

OS_SEM_CTR  OSSemPost ( OS_SEM  *p_sem,
                        OS_OPT   opt,
                        OS_ERR  *p_err )
{
    OS_SEM_CTR  ctr;
    CPU_TS      ts;



#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if ( p_sem == ( OS_SEM * ) 0 )                          /* Validate 'p_sem'                                       */
    {
        *p_err  = OS_ERR_OBJ_PTR_NULL;
        return ( ( OS_SEM_CTR ) 0 );
    }
    switch ( opt )                                          /* Validate 'opt'                                         */
    {
    case OS_OPT_POST_1:
    case OS_OPT_POST_ALL:
    case OS_OPT_POST_1   | OS_OPT_POST_NO_SCHED:
    case OS_OPT_POST_ALL | OS_OPT_POST_NO_SCHED:
        break;

    default:
        *p_err =  OS_ERR_OPT_INVALID;
        return ( ( OS_SEM_CTR ) 0u );
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
    if ( p_sem->Type != OS_OBJ_TYPE_SEM )                   /* Make sure semaphore was created                        */
    {
        *p_err = OS_ERR_OBJ_TYPE;
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

    ts = OS_TS_GET();                                       /* Get timestamp                                          */

#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
    if ( OSIntNestingCtr > ( OS_NESTING_CTR ) 0 )           /* See if called from an ISR                              */
    {
        OS_IntQPost ( ( OS_OBJ_TYPE ) OS_OBJ_TYPE_SEM,      /* Post to ISR queue                                      */
                      ( void      * ) p_sem,
                      ( void      * ) 0,
                      ( OS_MSG_SIZE ) 0,
                      ( OS_FLAGS   ) 0,
                      ( OS_OPT     ) opt,
                      ( CPU_TS     ) ts,
                      ( OS_ERR    * ) p_err );
        return ( ( OS_SEM_CTR ) 0 );
    }
#endif

    ctr = OS_SemPost ( p_sem,                               /* Post to semaphore                                      */
                       opt,
                       ts,
                       p_err );

    return ( ctr );
}

/*$PAGE*/
/*
************************************************************************************************************************
*                                                    SET SEMAPHORE
*
* Description: This function sets the semaphore count to the value specified as an argument.  Typically, this value
*              would be 0 but of course, we can set the semaphore to any value.
*
*              You would typically use this function when a semaphore is used as a signaling mechanism
*              and, you want to reset the count value.
*
* Arguments  : p_sem     is a pointer to the semaphore
*
*              cnt       is the new value for the semaphore count.  You would pass 0 to reset the semaphore count.
*
*              p_err     is a pointer to a variable that will contain an error code returned by this function.
*
*                            OS_ERR_NONE           The call was successful and the semaphore value was set.
*                            OS_ERR_OBJ_PTR_NULL   If 'p_sem' is a NULL pointer.
*                            OS_ERR_OBJ_TYPE       If 'p_sem' is not pointing to a semaphore.
*                            OS_ERR_TASK_WAITING   If tasks are waiting on the semaphore.
*
* Returns    : None
************************************************************************************************************************
*/

#if OS_CFG_SEM_SET_EN > 0u
void  OSSemSet ( OS_SEM      *p_sem,
                 OS_SEM_CTR   cnt,
                 OS_ERR      *p_err )
{
    OS_PEND_LIST  *p_pend_list;
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if ( OSIntNestingCtr > ( OS_NESTING_CTR ) 0 )           /* Can't call this function from an ISR                   */
    {
        *p_err = OS_ERR_SET_ISR;
        return;
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if ( p_sem == ( OS_SEM * ) 0 )                          /* Validate 'p_sem'                                       */
    {
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return;
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
    if ( p_sem->Type != OS_OBJ_TYPE_SEM )                   /* Make sure semaphore was created                        */
    {
        *p_err = OS_ERR_OBJ_TYPE;
        return;
    }
#endif

    *p_err = OS_ERR_NONE;
    CPU_CRITICAL_ENTER();
    if ( p_sem->Ctr > ( OS_SEM_CTR ) 0 )                    /* See if semaphore already has a count                   */
    {
        p_sem->Ctr = cnt;                                   /* Yes, set it to the new value specified.                */
    }
    else
    {
        p_pend_list = &p_sem->PendList;                     /* No                                                     */
        if ( p_pend_list->NbrEntries == ( OS_OBJ_QTY ) 0 )  /*      See if task(s) waiting?                           */
        {
            p_sem->Ctr = cnt;                               /*      No, OK to set the value                           */
        }
        else
        {
            *p_err      = OS_ERR_TASK_WAITING;
        }
    }
    CPU_CRITICAL_EXIT();
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                           CLEAR THE CONTENTS OF A SEMAPHORE
*
* Description: This function is called by OSSemDel() to clear the contents of a semaphore
*

* Argument(s): p_sem      is a pointer to the semaphore to clear
*              -----
*
* Returns    : none
*
* Note(s)    : 1) This function is INTERNAL to uC/OS-III and your application MUST NOT call it.
************************************************************************************************************************
*/

void  OS_SemClr ( OS_SEM  *p_sem )
{
    p_sem->Type    = OS_OBJ_TYPE_NONE;                      /* Mark the data structure as a NONE                      */
    p_sem->Ctr     = ( OS_SEM_CTR ) 0;                      /* Set semaphore value                                    */
    p_sem->TS      = ( CPU_TS    ) 0;                       /* Clear the time stamp                                   */
    p_sem->NamePtr = ( CPU_CHAR * ) ( ( void * ) "?SEM" );
    OS_PendListInit ( &p_sem->PendList );                   /* Initialize the waiting list                            */
}

/*$PAGE*/
/*
************************************************************************************************************************
*                                        ADD/REMOVE SEMAPHORE TO/FROM DEBUG LIST
*
* Description: These functions are called by uC/OS-III to add or remove a semaphore to/from the debug list.
*
* Arguments  : p_sem     is a pointer to the semaphore to add/remove
*
* Returns    : none
*
* Note(s)    : These functions are INTERNAL to uC/OS-III and your application should not call it.
************************************************************************************************************************
*/


#if OS_CFG_DBG_EN > 0u
void  OS_SemDbgListAdd ( OS_SEM  *p_sem )
{
    p_sem->DbgNamePtr               = ( CPU_CHAR * ) ( ( void * ) " " );
    p_sem->DbgPrevPtr               = ( OS_SEM   * ) 0;
    if ( OSSemDbgListPtr == ( OS_SEM * ) 0 )
    {
        p_sem->DbgNextPtr           = ( OS_SEM   * ) 0;
    }
    else
    {
        p_sem->DbgNextPtr           =  OSSemDbgListPtr;
        OSSemDbgListPtr->DbgPrevPtr =  p_sem;
    }
    OSSemDbgListPtr                 =  p_sem;
}



void  OS_SemDbgListRemove ( OS_SEM  *p_sem )
{
    OS_SEM  *p_sem_next;
    OS_SEM  *p_sem_prev;


    p_sem_prev = p_sem->DbgPrevPtr;
    p_sem_next = p_sem->DbgNextPtr;

    if ( p_sem_prev == ( OS_SEM * ) 0 )
    {
        OSSemDbgListPtr = p_sem_next;
        if ( p_sem_next != ( OS_SEM * ) 0 )
        {
            p_sem_next->DbgPrevPtr = ( OS_SEM * ) 0;
        }
        p_sem->DbgNextPtr = ( OS_SEM * ) 0;

    }
    else if ( p_sem_next == ( OS_SEM * ) 0 )
    {
        p_sem_prev->DbgNextPtr = ( OS_SEM * ) 0;
        p_sem->DbgPrevPtr      = ( OS_SEM * ) 0;

    }
    else
    {
        p_sem_prev->DbgNextPtr =  p_sem_next;
        p_sem_next->DbgPrevPtr =  p_sem_prev;
        p_sem->DbgNextPtr      = ( OS_SEM * ) 0;
        p_sem->DbgPrevPtr      = ( OS_SEM * ) 0;
    }
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                                SEMAPHORE INITIALIZATION
*
* Description: This function is called by OSInit() to initialize the semaphore management.
*

* Argument(s): p_err        is a pointer to a variable that will contain an error code returned by this function.
*
*                                OS_ERR_NONE     the call was successful
*
* Returns    : none
*
* Note(s)    : 1) This function is INTERNAL to uC/OS-III and your application MUST NOT call it.
************************************************************************************************************************
*/

void  OS_SemInit ( OS_ERR  *p_err )
{
#ifdef OS_SAFETY_CRITICAL
    if ( p_err == ( OS_ERR * ) 0 )
    {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#if OS_CFG_DBG_EN > 0u
    OSSemDbgListPtr = ( OS_SEM * ) 0;
#endif

    OSSemQty        = ( OS_OBJ_QTY ) 0;
    *p_err           = OS_ERR_NONE;
}

/*$PAGE*/
/*
************************************************************************************************************************
*                                                 POST TO A SEMAPHORE
*
* Description: This function signals a semaphore
*
* Arguments  : p_sem    is a pointer to the semaphore
*
*              opt      determines the type of POST performed:
*
*                           OS_OPT_POST_1            POST to a single waiting task
*                           OS_OPT_POST_ALL          POST to ALL tasks that are waiting on the semaphore
*
*                           OS_OPT_POST_NO_SCHED     Do not call the scheduler
*
*                           Note(s): 1) OS_OPT_POST_NO_SCHED can be added with one of the other options.
*
*              ts       is a timestamp indicating when the post occurred.
*
*              p_err    is a pointer to a variable that will contain an error code returned by this function.
*
*                           OS_ERR_NONE          The call was successful and the semaphore was signaled.
*                           OS_ERR_OBJ_PTR_NULL  If 'p_sem' is a NULL pointer.
*                           OS_ERR_OBJ_TYPE      If 'p_sem' is not pointing at a semaphore
*                           OS_ERR_SEM_OVF       If the post would cause the semaphore count to overflow.
*
* Returns    : The current value of the semaphore counter or 0 upon error.
*
* Note(s)    : This function is INTERNAL to uC/OS-III and your application should not call it.
************************************************************************************************************************
*/

OS_SEM_CTR  OS_SemPost ( OS_SEM  *p_sem,
                         OS_OPT   opt,
                         CPU_TS   ts,
                         OS_ERR  *p_err )
{
    OS_OBJ_QTY     cnt;
    OS_SEM_CTR     ctr;
    OS_PEND_LIST  *p_pend_list;
    OS_PEND_DATA  *p_pend_data;
    OS_PEND_DATA  *p_pend_data_next;
    OS_TCB        *p_tcb;
    CPU_SR_ALLOC();



    CPU_CRITICAL_ENTER();
    p_pend_list = &p_sem->PendList;
    if ( p_pend_list->NbrEntries == ( OS_OBJ_QTY ) 0 )      /* Any task waiting on semaphore?                         */
    {
        switch ( sizeof ( OS_SEM_CTR ) )
        {
        case 1u:
            if ( p_sem->Ctr == DEF_INT_08U_MAX_VAL )
            {
                CPU_CRITICAL_EXIT();
                *p_err = OS_ERR_SEM_OVF;
                return ( ( OS_SEM_CTR ) 0 );
            }
            break;

        case 2u:
            if ( p_sem->Ctr == DEF_INT_16U_MAX_VAL )
            {
                CPU_CRITICAL_EXIT();
                *p_err = OS_ERR_SEM_OVF;
                return ( ( OS_SEM_CTR ) 0 );
            }
            break;

        case 4u:
            if ( p_sem->Ctr == DEF_INT_32U_MAX_VAL )
            {
                CPU_CRITICAL_EXIT();
                *p_err = OS_ERR_SEM_OVF;
                return ( ( OS_SEM_CTR ) 0 );
            }
            break;

        default:
            break;
        }
        p_sem->Ctr++;                                       /* No                                                     */
        ctr       = p_sem->Ctr;
        p_sem->TS = ts;                                     /* Save timestamp in semaphore control block              */
        CPU_CRITICAL_EXIT();
        *p_err     = OS_ERR_NONE;
        return ( ctr );
    }

    OS_CRITICAL_ENTER_CPU_EXIT();
    if ( ( opt & OS_OPT_POST_ALL ) != ( OS_OPT ) 0 )        /* Post message to all tasks waiting?                     */
    {
        cnt = p_pend_list->NbrEntries;                      /* Yes                                                    */
    }
    else
    {
        cnt = ( OS_OBJ_QTY ) 1;                             /* No                                                     */
    }
    p_pend_data = p_pend_list->HeadPtr;
    while ( cnt > 0u )
    {
        p_tcb            = p_pend_data->TCBPtr;
        p_pend_data_next = p_pend_data->NextPtr;
        OS_Post ( ( OS_PEND_OBJ * ) ( ( void * ) p_sem ),
                  p_tcb,
                  ( void      * ) 0,
                  ( OS_MSG_SIZE ) 0,
                  ts );
        p_pend_data = p_pend_data_next;
        cnt--;
    }
    ctr = p_sem->Ctr;
    OS_CRITICAL_EXIT_NO_SCHED();
    if ( ( opt & OS_OPT_POST_NO_SCHED ) == ( OS_OPT ) 0 )
    {
        OSSched();                                          /* Run the scheduler                                      */
    }
    *p_err = OS_ERR_NONE;
    return ( ctr );
}

#endif
